package com.tennis.tennisreservation.service.impl;

import com.tennis.tennisreservation.entity.User;
import com.tennis.tennisreservation.repository.UserRepository;
import com.tennis.tennisreservation.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

/**
 * 用户服务实现类
 * 实现用户相关的业务逻辑方法
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserRepository userRepository;

    /**
     * 获取用户列表
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @param keyword 关键词（用户名或手机号）
     * @return 用户列表
     */
    @Override
    public List<User> getUserList(Integer pageNum, Integer pageSize, String keyword) {
        // 创建分页对象，注意：页码从0开始
        Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
        
        // 如果有关键词，则进行模糊搜索
        if (keyword != null && !keyword.trim().isEmpty()) {
            // 通过用户名或手机号模糊查询
            return userRepository.findByUsernameContainingOrPhoneContaining(keyword, keyword, pageable);
        } else {
            // 无关键词时，获取所有用户
            return userRepository.findAll(pageable).getContent();
        }
    }
    
    /**
     * 统计用户总数
     * @param keyword 关键词（用户名或手机号）
     * @return 用户总数
     */
    @Override
    public long countUsers(String keyword) {
        // 如果有关键词，则进行模糊搜索计数
        if (keyword != null && !keyword.trim().isEmpty()) {
            // 通过用户名或手机号模糊查询计数
            return userRepository.countByUsernameContainingOrPhoneContaining(keyword, keyword);
        } else {
            // 无关键词时，获取所有用户数量
            return userRepository.count();
        }
    }
    
    /**
     * 删除用户
     * @param id 用户ID
     */
    @Override
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }

    /**
     * 根据手机号查询用户
     * @param phone 用户手机号
     * @return 查询到的用户对象（可为空）
     */
    @Override
    public Optional<User> findByPhone(String phone) {
        return userRepository.findByPhone(phone);
    }

    /**
     * 保存用户信息
     * @param user 用户对象
     * @return 保存后的用户对象
     */
    @Override
    public User saveUser(User user) {
        // 设置更新时间
        user.setUpdateTime(LocalDateTime.now());
        // 如果是新用户，设置创建时间
        if (user.getId() == null) {
            user.setCreateTime(LocalDateTime.now());
        }
        
        return userRepository.save(user);
    }

    /**
     * 用户注册
     * @param phone 用户手机号
     * @return 注册后的用户信息
     */
    public User register(String phone) {
        // 检查手机号是否已注册
        Optional<User> existingUser = userRepository.findByPhone(phone);
        if (existingUser.isPresent()) {
            throw new IllegalArgumentException("手机号已注册");
        }

        // 创建新用户并保存
        User user = new User();
        user.setPhone(phone);
        user.setName("默认用户");  // 设置默认值
        user.setUsername(phone);  // 默认以手机号作为用户名
        user.setPassword("123456");  // 默认密码123456（明文）
        user.setRole("USER");  // 设置为普通用户
        user.setRechargeBalance(BigDecimal.ZERO);  // 初始余额为0
        user.setGiftBalance(BigDecimal.ZERO);  // 初始赠送余额为0
        user.setCreateTime(LocalDateTime.now());  // 创建时间
        user.setUpdateTime(LocalDateTime.now());  // 更新时间
        return userRepository.save(user); // 保存新用户到数据库
    }

     /**
     * 用户登录（手机号登录，已废弃）
     */
    @Override
    public User login(String phone) {
        Optional<User> existingUser = userRepository.findByPhone(phone);
        if (existingUser.isEmpty()) {
            throw new IllegalArgumentException("手机号未注册");
        }

        return existingUser.get();
    }
    
    /**
     * 用户名密码登录（简单验证，不使用加密）
     * @param username 用户名
     * @param password 密码（明文）
     * @return 登录的用户信息
     */
    @Override
    public User loginByUsername(String username, String password) {
        // 查找用户
        Optional<User> existingUser = userRepository.findByUsername(username);
        if (existingUser.isEmpty()) {
            throw new IllegalArgumentException("用户名不存在");
        }
        
        User user = existingUser.get();
        
        // 直接比较明文密码
        if (!password.equals(user.getPassword())) {
            throw new IllegalArgumentException("密码错误");
        }
        
        return user;
    }

    /**
     * 获取所有用户（不分页）
     * @return 所有用户列表
     */
    @Override
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    /**
     * 更新用户余额
     * @param userId 用户ID
     * @param rechargeBalance 充值余额
     * @param giftBalance 赠送余额
     * @return 更新后的用户信息
     */
    @Override
    @Transactional
    public User updateUserBalance(Long userId, String rechargeBalance, String giftBalance) {
        // 查找用户
        User user = userRepository.findById(userId)
                .orElseThrow(() -> new IllegalArgumentException("用户不存在: " + userId));
                
        // 更新余额
        user.setRechargeBalance(new java.math.BigDecimal(rechargeBalance));
        user.setGiftBalance(new java.math.BigDecimal(giftBalance));
        user.setUpdateTime(LocalDateTime.now());
        
        // 保存用户
        return userRepository.save(user);
    }

    /**
     * 根据ID查询用户
     * @param id 用户ID
     * @return 用户对象（可为空）
     */
    @Override
    public Optional<User> findById(Long id) {
        return userRepository.findById(id);
    }

    /**
     * 根据用户名查询用户
     * @param username 用户名
     * @return 用户对象（可为空）
     */
    @Override
    public Optional<User> findByUsername(String username) {
        return userRepository.findByUsername(username);
    }
}
